Generalized instancing for three-dimensional scene data

ABSTRACT

Systems and methods for rendering three-dimensional images by instancing scene description data using a hierarchy are provided. A hierarchy is accessed. The hierarchy comprises a first node and an instance node. The first node is a predecessor to a subtree of one or more nodes and the first node is associated with a first scene description data object. The instance node is a leaf of the hierarchy. The instance node has a parent node and the instance node is associated with a second scene description data object. The parent node has successor nodes other than the instance node. An instancing instruction of the instance node is read. The instancing instruction comprises information identifying the first node. An instance of the subtree of one or more nodes is merged at a location in the hierarchy of the instance node. An image is rendered based on the merged instance of the subtree.

BACKGROUND

1. Field

The present disclosure relates to computer-generated scene data and, more specifically, to a computer-generated scene data using hierarchy trees.

2. Related Art

A computer-generated animation is typically created by rendering a sequence of images, with each image depicting a computer-generated scene composed of one or more computer-generated objects (e.g., a character, tree, table, or chair). Frequently, the computer-generated images illustrate a scene containing multiples of similar objects (e.g., multiple characters, trees, tables, or chairs). For example, a scene may include hundreds of people sitting in the stands of a stadium at a sporting event or a scene may include a distribution of pine trees to produce a forest effect.

More specifically, when generating a virtual three-dimensional scene that includes a forest of pine trees, it is computationally less expensive to reproduce the same pine tree repeatedly to form the forest than it is to design, develop, maintain, and render hundreds of different trees to form the forest. Reproducing the same pine tree to form the forest is also much less time-consuming for the artist who is designing the scene.

However, it is not aesthetically desirable to have a forest of pine trees where all the pine trees in the forest are identical. Such a homogeneous forest is not realistic and would not be viewed as photorealistic to an observer who views the scene, such as in a rendered animation. Changing even minor details of the pine trees in the forest adds a high degree of realism. For example, changing the color of the trees, the texture of the trees, the number and placement of branches on the trees, and the color of the trees' leaves makes the forest, and therefore the scene including the forest, significantly more realistic.

More generally, the ability to reproduce multiple variations of assorted elements that extend beyond objects in a virtual three-dimensional scene is advantageous. It is therefore desirable to create a generalized system for configuring and managing the reproduction of elements in a computer-generated scene and applying variations to the reproductions.

SUMMARY

Processes for rendering three-dimensional images by instancing scene description data using a hierarchy are described. One example process may include accessing a hierarchy. The hierarchy comprises a first node and an instance node. The first node is a predecessor to a first subtree of one or more nodes and the first node is associated with a first scene description data object. The instance node is a leaf of the hierarchy. The instance node has a parent node and the instance node is associated with a second scene description data object. The parent node has successor nodes other than the instance node. An instancing instruction of the instance node is read. The instancing instruction comprises information identifying the first node. An instance of the first subtree of one or more nodes is merged at a location in the hierarchy of the instance node. An image is rendered based on the merged instance of the first subtree.

Systems and computer-readable storage media for rendering three-dimensional images by instancing scene description data using a hierarchy are also described.

BRIEF DESCRIPTION OF THE FIGURES

The present application can be best understood by reference to the following description taken in conjunction with the accompanying drawing figures, in which like parts may be referred to by like numerals.

FIG. 1 depicts an exemplary computer-generated image that may be rendered using a hierarchy tree according to various embodiments.

FIGS. 2A-B illustrate an exemplary source hierarchy and target hierarchy.

FIGS. 3A-B illustrate an exemplary source hierarchy and target hierarchy for an override of a node.

FIG. 4 illustrates an exemplary technique for recursively merging nodes.

FIGS. 5A-B illustrate an exemplary source hierarchy and target hierarchy for an override that adds an additional node.

FIGS. 6A-B illustrate an exemplary source hierarchy and target hierarchy for use with absolute and relative paths.

FIG. 7 illustrates an exemplary process for rendering three-dimensional images using a hierarchy.

FIG. 8 illustrates an exemplary computing system.

DETAILED DESCRIPTION

The following description is presented to enable a person of ordinary skill in the art to make and use the various embodiments. Descriptions of specific devices, techniques, and applications are provided only as examples. Various modifications to the examples described herein will be readily apparent to those of ordinary skill in the art, and the general principles defined herein may be applied to other examples and applications without departing from the spirit and scope of the present technology. Thus, the disclosed technology is not intended to be limited to the examples described herein and shown, but is to be accorded the scope consistent with the claims.

For descriptive purposes, throughout this disclosure, software, software modules, software objects, and the like may be described as performing various functions. One of ordinary skill in the art, however, will recognize that software may not actively perform any function and instead may include instructions that are executable on a computer processor. As such, although software may be described herein as performing a function, it should be appreciated that a computer processor or other computing device may typically perform those functions attributed herein to software modules or objects by executing computer instructions provided by the software modules or objects.

A computer-generated animation is typically created by rendering a sequence of images, each image depicting a computer-generated scene composed of one or more computer-generated objects. Light sources, materials, textures, and other visual effects may be associated with the computer-generated objects to create a realistic visual appearance for the computer-generated scene. For purposes of this discussion, a computer-generated scene generally refers to the virtual three-dimensional (3D) space that is able to be filmed using a virtual camera, and may also be referred to generically as a scene.

Various embodiments are described below relating to scene description data. The scene description data is structured as a hierarchy tree. The hierarchy tree is used to instance scene description data of a virtual three-dimensional scene. In addition, a variation can be applied to the instanced scene description data. For example, consider a character object that has a skin color characteristic and a hair color characteristic. This character may be instanced to produce a second character. In the second character, a variation can be applied to the skin color characteristic, such as to make the skin darker. As a result, a scene can simultaneously use both characters, with the first character having a lighter skin and the second character having a darker skin.

FIG. 1 depicts an exemplary computer-generated image that may be rendered using a hierarchy tree according to various embodiments. Notably, FIG. 1 depicts a scene of a crowd of characters in a stadium. To create such an image, an engineer traditionally individually configures each of the characters to produce the desired crowd. When a shared characteristic of the characters needs to be changed, the engineer must individually make the change for each of the characters. Maintaining the multiple copies of the characters causes the image creation process to be a difficult and burdensome task.

With reference to FIG. 1, rendering the same scene using generalized instancing in a hierarchy tree, an engineer can create additional instances of a character and apply variations to the instanced characters. This technique allows the characters in the crow to share certain characteristics, while enabling the engineer to change individual characteristics of the instanced characters. As a result, less data is stored to represent the crowd of characters and less overhead maintenance of the characters is required. These characters are scene description data.

As described above, the scene description data is structured as a hierarchy tree. The topmost node in the hierarchy tree is called the root node. The root node does not have a parent. Internal nodes of the hierarchy tree are nodes that have one or more children. Leaf nodes of the hierarchy tree are the nodes of the hierarchy tree that do not have children. The leaf nodes of the hierarchy tree represent data (e.g., strings, integers, vectors, or polygon meshes). The internal nodes of the hierarchy tree represent groups of data. For example, leaf nodes may represent geometry meshes, visual effect objects, materials to be applied to geometry, virtual cameras, lighting rigs, light filters, and the like. Edges or links connect various nodes in the hierarchy tree.

FIG. 2 illustrates an exemplary source hierarchy and target hierarchy. The semantics of instancing are described in terms of a transformation between source hierarchy 200 and target hierarchy 220.

Source hierarchy 200 includes root node 202, internal nodes 204-210, and leaf nodes 212-218. Each of nodes 212, 214, and 216 represent scene description data. Node 218 is a leaf node that is an instance node. An instance node includes a special instancing tag. For example, the instance node contains a tag of “instance parent” and a value. This “instance parent” tag may be referred to as an instancing instruction tag. The value of the instance node is a path to another node in the tree to be instanced. Similarly, the instance node may include an instruction to instance another node in the tree and the instance node may specify which node in the tree should be instanced.

As an example, the path to leaf node 216 may be “1,1,2,2.” The path is annotated for ease of understanding as follows: 1 [resulting from tag=1 of node 202], 1 [resulting from tag=1 of node 204], 2 [resulting from tag=2 of node 210], 2 [resulting from tag=2 of node 216].

The node to be instanced is called an instance parent node. In the example of FIG. 2A, node 218 is an instance parent node. The instance instruction tag and path to the instance parent node are symbolized by the dashed line from instance node 218 to instance parent node 204. In this example, instance parent node 218 has a path of “1,1.” When the instance instruction tag is executed, the path stored in the instance node is traversed and copies of all child nodes of the instance parent node 204 are inserted as siblings of the instance node 218 to produce target hierarchy 220, as illustrated in FIG. 2B. In FIG. 2A, the child nodes of instance parent node 204 are nodes 208-216. The instance node 218 is removed. Phrased differently, the child nodes of the instance parent node 204 replace the instance node 218.

In the example of FIG. 2B, source hierarchy 200 has been executed, resulting in target hierarchy 220. As discussed above, when an instance node is executed, copies of all child nodes of the instance parent node are inserted as siblings of the instance node to produce a target hierarchy. Target hierarchy 220 has a similar structure as source hierarchy 200, with the addition of internal nodes 222 and 224 and leaf nodes 226, 228, and 230. Importantly, instanced leaf nodes 226, 228, and 230 have the same tags, values, and characteristics as leaf nodes 212, 214, and 216, respectively.

When an instance parent node is instanced as a result of an instancing instruction, all child nodes of the instance parent are copied. This copy is a deep copy. A deep copy means that the entire subtree below the instance parent node is copied.

In one example, node 204 of FIG. 2 represents a virtual object to be placed in a virtual scene. Node 204 is a grouping of elements to be used to produce the virtual object. The different elements of the virtual object are represented by leaf nodes 212, 214, and 216. Node 212 represents a geometric mesh of the object, node 214 represents a material property of the object (e.g., the color of the object), and node 216 represents a transform characteristic of the object (e.g., the position, rotation, and scale of the object). As an example, node 214 representing a material property of the object has a value of “B,” as illustrated in FIG. 2A.

Node 206 of FIG. 2 represents a second virtual object to be placed in the same scene as the virtual object represented by node 204. When the instancing instruction of instance node 218 is executed, a deep copy of the child nodes of instance parent node 204 occurs. The nodes 208-216 are copied to produce nodes 222-230. Node 206 connects to nodes 222-230 and is associated with the data contained in nodes 226-230. In particular, node 206 is a grouping of elements to be used to produce the virtual object. Node 226 represents a geometric mesh of the object and has the same value as node 212, node 228 represents a material property of the object (e.g., the color of the object) and has the same value as node 214, and node 230 represents a transform characteristic of the object (e.g., the position, rotation, and scale of the object) and has the same value as node 216. As an example, node 228 representing a material property of the object has the same value “B” as node 214, as illustrated in FIG. 2B.

FIG. 3 illustrates an exemplary source hierarchy and target hierarchy for an override of a node. The semantics of instancing are described in terms of a transformation between source hierarchy 300 and target hierarchy 330.

Source hierarchy 300 includes root node 302, internal nodes 304-310 and 320, and leaf nodes 312-318 and 322. Each of nodes 312, 314, 316, and 322 represent scene description data. Node 318 is a leaf node that is an instance node. As illustrated by the dashed line in FIG. 3A, instance node 318 contains a tag of “instance parent” and a value that is a path to the instance parent node 304. For example, the path to the instance parent may be expressed as “1-1.” The first “1” identifies node 302 and the second “1” indicates node 304.

In contrast to source hierarchy 200 of FIG. 2A, source hierarchy 300 of FIG. 3A includes an instance node 318 that has a sibling. In other words, nodes that represent instancing instructions may have sibling nodes in the source hierarchy. These sibling nodes may be either leaf nodes or internal nodes. As illustrated in FIG. 3A, internal node 320 and instance node 318 are sibling nodes because internal node 320 and instance node 318 share the same direct parent node—node 306.

In the example of FIG. 3B, source hierarchy 300 has been executed, resulting in target hierarchy 330. As discussed above, when an instance node is executed, copies of all child nodes of the instance parent node are inserted as siblings of the instance node to produce a target hierarchy. This copy may result in a collision between two or more nodes. Collisions occur when a copied node (resulting from instancing) and a pre-existing node have the same tag (e.g., they describe the same scene description data at the same location in the hierarchy tree). When a collision occurs, child nodes of the instanced parent are merged with the existing nodes to produce the target hierarchy.

We now refer back to FIG. 3A to describe how the child nodes of the instanced parent are merged with the existing nodes to produce target hierarchy 330. Importantly, in this example internal node 320 (tag=2) and internal node 310 (tag=2) have the same tag. As a result, a collision occurs between these two internal nodes when the instancing instruction of instance node 318 is executed. Because both internal node 320 and internal node 310 are non-leaf nodes, their child nodes are merged.

Internal node 320 of the source hierarchy has a child node 322 (tag=1). Internal node 310 (tag=2) has child nodes 314 (tag=1) and 316 (tag=2). When the child nodes of node 310 are merged with the child nodes of 320, another collision occurs. This collision occurs between the copy of leaf node 314 (tag=1), which is being copied to be a direct child of node 320, and leaf node 322 (tag=1). The collision occurs because the copy operation results in two nodes having the same tag value at the same location in the tree. If either node involved in a collision is a leaf node, the collision is resolved in favor of the pre-existing node. In other words, the pre-existing node from the source tree is retained in the target tree. In this example, both nodes involved in the collision are leaf nodes. Therefore, the collision is resolved in favor of leaf node 322. The other child node of node 310, leaf node 316, does not cause a collision and is therefore copied to be a direct child of node 320. This copy of lead node 316 is illustrated in FIG. 3B as leaf node 336. Similarly, node 308 and 312 are copied to the subtree of node 306 as nodes 332 and 334, respectively.

As a result of this merge, pre-existing data in the tree overrides newly copied data and a variation of the subtree of the instance parent node is produced.

FIG. 4 illustrates an exemplary technique for recursively merging nodes. The process starts at block 402. Block 404 indicates that the process is performed for each sibling of the current set of nodes being merged. The technique proceeds to block 406 for a node of the set of nodes being merged. At block 406, if the system detects that the node causes a collision, the process moves to block 408. A collision may be detected by comparing the tag of the node being copied to a particular location of the hierarchy tree with the tags of the pre-existing nodes at the location in the hierarchy tree. If the node being copied has the same tag value as an existing node, the two nodes will cause a collision. At block 408, the system determines if either node that has caused a collision is a leaf node. If either node is a leaf node, the system moves to block 414. If neither node is a leaf node, the system moves to block 410.

At block 414, the system retains the pre-existing node. The node being copied is discarded. In one example, the pre-existing node may be a leaf node that overrides a leaf node or an internal node. In another example, the pre-existing node may be an internal node that overrides a leaf node. The system then moves to block 412.

At block 410, the system calls the process to merge the children of the two nodes. The process of diagram 400 may be called recursively to accomplish this.

At block 412, the system determines if any more sibling nodes remain to be copied. If no siblings remain to be copied, the process ends at block 416. If the system determines that one or more sibling nodes remain to be copied, the system returns to block 404 and progresses with the next sibling node.

Using this override technique, the system can modify any property defined by a leaf node. Further, the system can add additional nodes as part of a merge. An example of adding an additional node is illustrated in FIG. 5.

FIG. 5 illustrates an exemplary source hierarchy and target hierarchy for an override that adds an additional node. The semantics of instancing are described in terms of a transformation between source hierarchy 500 and target hierarchy 530.

In FIG. 5A, source hierarchy 500 includes root node 502, internal nodes 504-510 and 520, and leaf nodes 512-518 and 522. Each of nodes 512, 514, 516, and 522 represent scene description data. Node 518 is a leaf node that is an instance node, as illustrated by the dashed line in FIG. 5A.

Importantly, leaf node 522 has a tag with a value of 3 (tag=3). When instancing occurs in this example, the only collision will be between node 510 and 520. There will not be any collision between node 522 (tag=3) and the copies of nodes 514 (tag=1) and 516 (tag=2).

In the example of FIG. 5B, source hierarchy 500 has been executed, resulting in target hierarchy 530. Similar to previous examples, nodes 532, 534, 536, and 538 are populated. However, in this example an additional node is also stored. More specifically, the groups 510 and 520 are identical other than the additional leaf node 522 (tag=3). This example illustrates the concept that additional nodes (and therefore additional scene description data) may be added through the instancing process. Thus, an override may also add nodes because the target hierarchy is a merge of the instance parent copy and the override data (e.g., node 522 of FIG. 5A). For example, a camera rig may be instanced to produce a camera rig, the produced camera rig having a subtree that has an additional node as compared to the original camera rig. This additional node may describe, for example, a camera filter or other scene description data.

An additional property of the system is that leaf nodes can store values that are interpreted as references to other nodes in the hierarchy. For example, this may be achieved by storing a path value that is a sequence of tags, as described above. An absolute reference is a path that is intended to be interpreted from the root node.

However, a path can also be interpreted as a path to be traversed starting from the parent of the leaf node where it is stored. This is called a relative reference and has several useful properties when it is a node that is instanced. For example, an instanced copy of a node containing a relative reference refers to the corresponding instance of the original referenced node, and not to the original node itself. This creates modularity in the system, enabling the generalized instancing of a subtree to behave as expected even when the subtree contains internal references.

FIG. 6 illustrates an exemplary source hierarchy and target hierarchy for use with absolute and relative paths. In FIG. 6A, source hierarchy 600 includes root node 602, internal nodes 604-610 and 616, and leaf nodes 612, 614, 618, and 620. Node 620 is a leaf node that is an instance node, as illustrated by the dashed line in FIG. 6A.

Leaf node 614 may include a reference to node 618. This reference is stored as a path. As discussed above, the path can be absolute or relative. An absolute reference results in every instance of leaf node 614 referencing node 618. A relative reference results in every instance of leaf node 614 referencing the node that is situated at the same path as relative to node 614.

For example, consider the target hierarchy 640 of FIG. 6B that results from instancing. In FIG. 6B, target hierarchy 640 includes root node 602, internal nodes 604-610, 616, 622, 624, and 630, and leaf nodes 612, 614, 618, 626, 628, and 632. If leaf node 614 contained an absolute reference to node 618, instanced leaf node 628 would also contain an absolute reference to leaf node 618. An example of this absolute reference is “1, 1, 2, 2, 1.” However, if leaf node 614 contained a relative reference to node 618, instanced leaf node 628 would contain a relative reference to leaf node 632. An example of this relative reference is “2, 1.” This relative reference is interpreted as a path to be traversed starting from the parent of the leaf node where it is stored. In this example, the parent of node 628 is node 624. Traversing the path “2, 1” starting at node 624 results in a path to leaf node 632. In some examples, a flag or indicator is stored along with the reference to indicate whether the reference is a relative reference or an absolute reference.

Another feature of the system is the ability for relative reference to contain a special additional token called “Move to Parent.” This may be interpreted as an instruction, rather than a tag. The instruction is to move up one level in the hierarchy while traversing the tree to compute the referent. This may be thought of as analogous to the special directory name “ . . . ” available in unix systems and file path names.

FIG. 7 illustrates an exemplary process for rendering three-dimensional images by instancing scene description data using a hierarchy. At block 702, the hierarchy is accessed. The hierarchy comprises a first node. The first node is a predecessor to a first subtree of one or more nodes. In other words, the one or more nodes of the first subtree are the children and grandchildren of the first node. The first node is associated with a first scene description data object. Scene description data objects may include, for example, objects for geometry, virtual cameras, lighting rigs, light sources, light filters, materials, textures, and other visual effects. The hierarchy also comprises an instance node. The instance node is a leaf of the hierarchy. The instance node has a parent node and the instance node is associated with a second scene description data object. The parent node of the instance node has successor nodes other than the instance node. These successor nodes may be internal nodes and/or leaf nodes.

At block 704, an instancing instruction of the instance node is read. The instancing instruction comprises information identifying the first node. The instancing instruction may be a special tag and value of the instance node.

At block 706, an instance of the first subtree is merged. The instance of the first subtree of one or more nodes is merged at a location in the hierarchy of the instance node. Merging may include determining a conflict between (a) at least one node of the first subtree and (b) at least one node of the successor nodes other than the instance node of the parent node. Merging may also include overriding a first value of a property defined by the (b) at least one node of the successor nodes by using a second value of the property defined by the (a) at least one node of the first subtree.

A conflict may be determined by accessing a first tag of the (a) at least one node of the first subtree, wherein the first tag has a tag value, and accessing a second tag of the (b) at least one node of the successor nodes, wherein the second tag has the same tag value. Because the tag values are the same and the two nodes would otherwise be siblings, a conflict is determined between the two nodes. Generally speaking, tag values are used to uniquely identify sibling nodes in the hierarchy.

In some examples, the first node may also have a tag, such as a third tag. The information identifying the first node includes a path, which uses the third tag.

In some examples, the first subtree comprises a second node including a relative reference, the relative reference of the second node identifies a first identified node in the first subtree. The merged instance of the first subtree comprises a third node including the relative reference. The relative reference of the third node identifies a second identified node in the merged instance of the first subtree. The first identified node and the second identified node are not the same node.

In other examples, the first subtree comprises a second node including an absolute reference. The absolute reference of the second node identifies a first identified node in the first subtree. The merged instance of the first subtree comprises a third node including the absolute reference. The absolute reference of the third node identifies the first identified node in the first subtree.

In addition, the first subtree may comprise a fourth node, which includes data that comprises a parent token. The parent token indicates an instruction to move up one level in the hierarchy.

At block 708, an image is rendered based on the merged instance of the first subtree.

FIG. 8 illustrates an exemplary animation system 800 that can be used to implement the hierarchy technique discussed above. The hierarchy technique can be implemented, for example, in either hardware or in software stored on a non-transitory computer-readable storage medium.

The animation system 800 can be configured to receive user input from an input device 820. The input device 820 can be any device that receives input from the user and transmits it to the animation system 800. For example, the input device 820 can be a keyboard, a mouse, a tablet, a stylus, or the like. Those skilled in the art will recognize that other types of input devices can also be used.

The animation system 800 can be configured to output graphics, images, or animation to an output device 830. The output device 830 can include any device that receives data from the animation system and presents the data to the user. For example, the output device 830 may include a liquid crystal display, a set of light-emitting diodes, a projector, or the like. Those skilled in the art will recognize that other types of output devices can also be used.

The animation system 800 may further include a central processing unit 802. The central processing unit may include one or more processing cores. The central processing unit 802 may be coupled to and able to communicate with the input device 820. Although the animation system 800 is illustrated with one central processing unit 802, the animation system 800 may include multiple processing units. The animation system 800 may also include a graphics processing unit 804. The graphics processing unit 804 may be dedicated to processing graphics-related data. The graphics processing unit 804 may include a single processing core or multiple processing cores. Although the animation system 800 is illustrated with one graphics processing unit 804, the animation system 800 may include a plurality of graphics processing units. The central processing unit 802 and/or the graphics processing unit 804 may be coupled to and able to communicate data to the output device 830.

In one example, the animation system 800 may include one or more processors and instructions stored in a non-transitory computer-readable storage medium, such as a memory or storage device, that when executed by the one or more processors, perform animation rendering using the hierarchy technique described above. In the context of the embodiments described herein, a “non-transitory computer-readable storage medium” can be any medium that can contain or store the program for use by or in connection with the instruction execution system, apparatus, or device. The non-transitory computer-readable storage medium can include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, a portable computer diskette (magnetic), a random access memory (RAM) (magnetic), a read-only memory (ROM) (magnetic), an erasable programmable read-only memory (EPROM) (magnetic), a portable optical disc such a CD, CD-R, CD-RW, DVD, DVD-R, or DVD-RW, or flash memory such as compact flash cards, secured digital cards, USB memory devices, memory sticks, and the like.

The animation system 800 may include volatile memory 806, which is a non-transitory computer-readable storage medium, in communication with the central processing unit 802. The volatile memory 806 may include, for example, random access memory, such as dynamic random access memory or static random access memory, or any other type of volatile memory. The volatile memory 806 may be used to store data or instructions during the operation of the animation system 800. Those skilled in the art will recognize that other types of volatile memory can also be used.

The animation system 800 may also include non-volatile memory 808, which is a non-transitory computer-readable storage medium, in communication with the central processing unit 802. The non-volatile memory 808 may include flash memory, hard disks, magnetic storage devices, read-only memory, or the like. The non-volatile memory 808 may be used to store animation data, render setup graph data, computer instructions, or any other information. Those skilled in the art will recognize that other types of non-volatile memory can also be used.

The animation system 800 is not limited to the devices, configurations, and functionalities described above. For example, although a single volatile memory 806, non-volatile memory 808, central processing unit 802, graphics processing unit 804, input device 820, and output device 830 are illustrated, a plurality of any of these devices can be implemented internal or external to the animation system 800. In addition, the animation system 800 may include a network access device for accessing information on a network, such as an internal network or the Internet. Those skilled in the art will recognize that other configurations of the animation system 800 can be used.

Various exemplary embodiments are described herein. Reference is made to these examples in a non-limiting sense. They are provided to more broadly illustrate applicable aspects of the disclosed technology. Various changes may be made and equivalents may be substituted without departing from the true spirit and scope of the various embodiments. In addition, many modifications may be made to adapt a particular situation, material, composition of matter, process, process act(s), or step(s) to the objective(s), spirit, or scope of the various embodiments. Further, as will be appreciated by those with skill in the art, each of the individual variations described and illustrated herein has discrete components and features that may be readily separated from or combined with the features of any of the other several embodiments without departing from the scope or spirit of the various embodiments. 

What is claimed is:
 1. A computer-implemented method for rendering three-dimensional images by instancing scene description data using a hierarchy, the method comprising: accessing the hierarchy, the hierarchy comprising: a first node, the first node being a predecessor to a first subtree of one or more nodes and the first node being associated with a first scene description data object; an instance node, the instance node being a leaf of the hierarchy, the instance node having a parent node, and the instance node being associated with a second scene description data object, and wherein the parent node has successor nodes other than the instance node; reading an instancing instruction of the instance node, the instancing instruction comprising information identifying the first node; merging an instance of the first subtree of one or more nodes at a location in the hierarchy of the instance node; and rendering an image based on the merged instance of the first subtree.
 2. The computer-implemented method of claim 1, wherein merging comprises: determining a conflict between (a) at least one node of the first subtree and (b) at least one node of the successor nodes other than the instance node of the parent node; and overriding a first value of a property defined by the (b) at least one node of the successor nodes by using a second value of the property defined by the (a) at least one node of the first subtree.
 3. The computer-implemented method of claim 1, wherein merging further comprises: determining the conflict by: accessing a first tag of the (a) at least one node of the first subtree, the first tag having a tag value; accessing a second tag of the (b) at least one node of the successor nodes, the second tag having the tag value; and wherein tag values uniquely identify sibling nodes in the hierarchy.
 4. The computer-implemented method of claim 3, wherein: the first node has a third tag; the information identifying the first node comprises a path; and the path includes the third tag of the first node.
 5. The computer-implemented method of claim 1, wherein: the first subtree comprises a second node including a relative reference, the relative reference of the second node identifying a first identified node in the first subtree; the merged instance of the first subtree comprises a third node including the relative reference, the relative reference of the third node identifying a second identified node in the merged instance of the first subtree; and wherein the first identified node and the second identified node are not the same node.
 6. The computer-implemented method of claim 1, wherein: the first subtree comprises a second node including an absolute reference, the absolute reference of the second node identifying a first identified node in the first subtree; and the merged instance of the first subtree comprises a third node including the absolute reference, the absolute reference of the third node identifying the first identified node in the first subtree.
 7. The computer-implemented method of claim 1, wherein: the first subtree comprises a fourth node including data that comprises a parent token, the parent token indicating an instruction to move up one level in the hierarchy.
 8. A non-transitory computer-readable storage medium comprising computer-executable instructions for rendering three-dimensional images by instancing scene description data using a hierarchy, the computer-executable instructions comprising instructions for: accessing the hierarchy, the hierarchy comprising: a first node, the first node being a predecessor to a first subtree of one or more nodes and the first node being associated with a first scene description data object; an instance node, the instance node being a leaf of the hierarchy, the instance node having a parent node, and the instance node being associated with a second scene description data object, and wherein the parent node has successor nodes other than the instance node; reading an instancing instruction of the instance node, the instancing instruction comprising information identifying the first node; merging an instance of the first subtree of one or more nodes at a location in the hierarchy of the instance node; and rendering an image based on the merged instance of the first subtree.
 9. The non-transitory computer-readable storage medium of claim 8, wherein merging comprises instructions for: determining a conflict between (a) at least one node of the first subtree and (b) at least one node of the successor nodes other than the instance node of the parent node; and overriding a first value of a property defined by the (b) at least one node of the successor nodes by using a second value of the property defined by the (a) at least one node of the first subtree.
 10. The non-transitory computer-readable storage medium of claim 8, wherein merging further comprises instructions for: determining the conflict by: accessing a first tag of the (a) at least one node of the first subtree, the first tag having a tag value; accessing a second tag of the (b) at least one node of the successor nodes, the second tag having the tag value; and wherein tag values uniquely identify sibling nodes in the hierarchy.
 11. The non-transitory computer-readable storage medium of claim 10, wherein: the first node has a third tag; the information identifying the first node comprises a path; and the path includes the third tag of the first node.
 12. The non-transitory computer-readable storage medium of claim 8, wherein: the first subtree comprises a second node including a relative reference, the relative reference of the second node identifying a first identified node in the first subtree; the merged instance of the first subtree comprises a third node including the relative reference, the relative reference of the third node identifying a second identified node in the merged instance of the first subtree; and wherein the first identified node and the second identified node are not the same node.
 13. The non-transitory computer-readable storage medium of claim 8, wherein: the first subtree comprises a second node including an absolute reference, the absolute reference of the second node identifying a first identified node in the first subtree; and the merged instance of the first subtree comprises a third node including the absolute reference, the absolute reference of the third node identifying the first identified node in the first subtree.
 14. The non-transitory computer-readable storage medium of claim 8, wherein: the first subtree comprises a fourth node including data that comprises a parent token, the parent token indicating an instruction to move up one level in the hierarchy.
 15. An apparatus for rendering three-dimensional images by instancing scene description data using a hierarchy, the apparatus comprising: a memory configured to store the hierarchy; and one or more computer processors configured to: access the hierarchy, the hierarchy comprising: a first node, the first node being a predecessor to a first subtree of one or more nodes and the first node being associated with a first scene description data object; an instance node, the instance node being a leaf of the hierarchy, the instance node having a parent node, and the instance node being associated with a second scene description data object, and wherein the parent node has successor nodes other than the instance node; read an instancing instruction of the instance node, the instancing instruction comprising information identifying the first node; merge an instance of the first subtree of one or more nodes at a location in the hierarchy of the instance node; and render an image based on the merged instance of the first subtree.
 16. The apparatus of claim 15, the one or more computer processors further configured to: determine a conflict between (a) at least one node of the first subtree and (b) at least one node of the successor nodes other than the instance node of the parent node; and override a first value of a property defined by the (b) at least one node of the successor nodes by using a second value of the property defined by the (a) at least one node of the first subtree.
 17. The apparatus of claim 15, the one or more computer processors further configured to: determine the conflict by: accessing a first tag of the (a) at least one node of the first subtree, the first tag having a tag value; accessing a second tag of the (b) at least one node of the successor nodes, the second tag having the tag value; and wherein tag values uniquely identify sibling nodes in the hierarchy.
 18. The apparatus of claim 17, wherein: the first node has a third tag; the information identifying the first node comprises a path; and the path includes the third tag of the first node.
 19. The apparatus of claim 15, wherein: the first subtree comprises a second node including a relative reference, the relative reference of the second node identifying a first identified node in the first subtree; the merged instance of the first subtree comprises a third node including the relative reference, the relative reference of the third node identifying a second identified node in the merged instance of the first subtree; and wherein the first identified node and the second identified node are not the same node.
 20. The apparatus of claim 15, wherein: the first subtree comprises a second node including an absolute reference, the absolute reference of the second node identifying a first identified node in the first subtree; and the merged instance of the first subtree comprises a third node including the absolute reference, the absolute reference of the third node identifying the first identified node in the first subtree.
 21. The apparatus of claim 15, wherein: the first subtree comprises a fourth node including data that comprises a parent token, the parent token indicating an instruction to move up one level in the hierarchy. 